const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()

exports.main = async (event, context) => {
  console.log('开始初始化数据库集合')
  
  const results = []
  
  try {
    // 创建用户集合
    const usersResult = await createUsersCollection()
    results.push(usersResult)
    
    // 创建订单集合
    const ordersResult = await createOrdersCollection()
    results.push(ordersResult)
    
    // 创建项目集合
    const projectsResult = await createProjectsCollection()
    results.push(projectsResult)
    
    // 创建通知集合
    const notificationsResult = await createNotificationsCollection()
    results.push(notificationsResult)
    
    console.log('数据库初始化完成，结果:', results)
    
    return {
      success: true,
      message: '数据库初始化完成',
      details: results
    }
  } catch (error) {
    console.error('数据库初始化失败:', error)
    return {
      success: false,
      error: error.message,
      details: results
    }
  }
}

// 创建用户集合
async function createUsersCollection() {
  try {
    console.log('开始创建用户集合...')
    
    // 尝试直接插入一条测试数据来创建集合
    await db.collection('users').add({
      data: {
        _test: true,
        createTime: new Date(),
        note: '测试数据，用于创建集合'
      }
    })
    
    console.log('用户集合创建成功')
    
    // 创建索引
    try {
      await db.collection('users').createIndex({
        keys: { openid: 1 },
        unique: true
      })
      console.log('用户集合openid索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('用户集合openid索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('users').createIndex({
        keys: { unionid: 1 }
      })
      console.log('用户集合unionid索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('用户集合unionid索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('users').createIndex({
        keys: { userId: 1 },
        unique: true
      })
      console.log('用户集合userId索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('用户集合userId索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('users').createIndex({
        keys: { userNumber: 1 },
        unique: true
      })
      console.log('用户集合userNumber索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('用户集合userNumber索引创建失败:', indexError.message)
      }
    }
    
    return { collection: 'users', status: 'success', message: '用户集合创建成功' }
  } catch (error) {
    console.error('创建用户集合失败:', error)
    return { collection: 'users', status: 'error', message: error.message }
  }
}

// 创建订单集合
async function createOrdersCollection() {
  try {
    console.log('开始创建订单集合...')
    
    // 尝试直接插入一条测试数据来创建集合
    await db.collection('orders').add({
      data: {
        _test: true,
        createTime: new Date(),
        note: '测试数据，用于创建集合'
      }
    })
    
    console.log('订单集合创建成功')
    
    // 创建索引
    try {
      await db.collection('orders').createIndex({
        keys: { openid: 1, createTime: -1 }
      })
      console.log('订单集合复合索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('订单集合复合索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('orders').createIndex({
        keys: { status: 1 }
      })
      console.log('订单集合状态索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('订单集合状态索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('orders').createIndex({
        keys: { id: 1 },
        unique: true
      })
      console.log('订单集合ID索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('订单集合ID索引创建失败:', indexError.message)
      }
    }
    
    return { collection: 'orders', status: 'success', message: '订单集合创建成功' }
  } catch (error) {
    console.error('创建订单集合失败:', error)
    return { collection: 'orders', status: 'error', message: error.message }
  }
}

// 创建项目集合
async function createProjectsCollection() {
  try {
    console.log('开始创建项目集合...')
    
    // 尝试直接插入一条测试数据来创建集合
    await db.collection('projects').add({
      data: {
        _test: true,
        createTime: new Date(),
        note: '测试数据，用于创建集合'
      }
    })
    
    console.log('项目集合创建成功')
    
    // 创建索引
    try {
      await db.collection('projects').createIndex({
        keys: { openid: 1, createTime: -1 }
      })
      console.log('项目集合复合索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('项目集合复合索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('projects').createIndex({
        keys: { status: 1 }
      })
      console.log('项目集合状态索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('项目集合状态索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('projects').createIndex({
        keys: { id: 1 },
        unique: true
      })
      console.log('项目集合ID索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('项目集合ID索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('projects').createIndex({
        keys: { orderId: 1 }
      })
      console.log('项目集合订单ID索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('项目集合订单ID索引创建失败:', indexError.message)
      }
    }
    
    return { collection: 'projects', status: 'success', message: '项目集合创建成功' }
  } catch (error) {
    console.error('创建项目集合失败:', error)
    return { collection: 'projects', status: 'error', message: error.message }
  }
}

// 创建通知集合
async function createNotificationsCollection() {
  try {
    console.log('开始创建通知集合...')
    
    // 尝试直接插入一条测试数据来创建集合
    await db.collection('notifications').add({
      data: {
        _test: true,
        createTime: new Date(),
        note: '测试数据，用于创建集合'
      }
    })
    
    console.log('通知集合创建成功')
    
    // 创建索引
    try {
      await db.collection('notifications').createIndex({
        keys: { openid: 1, createTime: -1 }
      })
      console.log('通知集合复合索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('通知集合复合索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('notifications').createIndex({
        keys: { isRead: 1 }
      })
      console.log('通知集合已读状态索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('通知集合已读状态索引创建失败:', indexError.message)
      }
    }
    
    try {
      await db.collection('notifications').createIndex({
        keys: { type: 1 }
      })
      console.log('通知集合类型索引创建成功')
    } catch (indexError) {
      if (!indexError.message.includes('already exists')) {
        console.warn('通知集合类型索引创建失败:', indexError.message)
      }
    }
    
    return { collection: 'notifications', status: 'success', message: '通知集合创建成功' }
  } catch (error) {
    console.error('创建通知集合失败:', error)
    return { collection: 'notifications', status: 'error', message: error.message }
  }
}

// 清理测试数据（可选调用）
async function cleanTestData() {
  try {
    console.log('开始清理测试数据...')
    
    const collections = ['users', 'orders', 'projects', 'notifications']
    
    for (const collectionName of collections) {
      try {
        await db.collection(collectionName).where({
          _test: true
        }).remove()
        console.log(`${collectionName} 集合测试数据清理完成`)
      } catch (error) {
        console.warn(`清理 ${collectionName} 集合测试数据失败:`, error.message)
      }
    }
    
    return { status: 'success', message: '测试数据清理完成' }
  } catch (error) {
    console.error('清理测试数据失败:', error)
    return { status: 'error', message: error.message }
  }
}
